using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.TextCore.Text;

/// <summary>
/// 攻击状态
/// </summary>
public class AttackState : IFsmState
{
    private float m_AttackCooldown;
    private Entity m_CurrentTarget;
    private Rigidbody2D m_Rigidbody;

    public void Enter(Entity entity, params object[] args)
    {
        // 停止移动
        m_Rigidbody = entity.GetComponent<Rigidbody2D>();
        if (m_Rigidbody != null)
        {
            m_Rigidbody.velocity = Vector2.zero;
        }

        // 设置攻击动画
        if (entity.Animator != null)
        {
            entity.Animator.SetBool("attack", true);
        }

        // 重置攻击冷却时间
        m_AttackCooldown = 0f;

        // 检查是否需要查找攻击目标
        bool requiresTarget = entity.AttackComponent?.AttackData?.RequiresTarget ?? true;
        
        if (!requiresTarget)
        {
            // 不需要目标的技能（如向日葵生产阳光、火爆辣椒等），直接执行
            ExecuteAttack(entity, null);
            Logger.Log("AttackState", $"进入攻击状态 ===>>> {entity.name} 开始执行技能（无需目标）");
        }
        else
        {
            // 其他攻击类型：需要目标
            // 获取目标（优先使用传入的目标，否则查找）
            m_CurrentTarget = args != null && args.Length > 0 && args[0] is Entity target ? target : entity.AttackComponent?.FindEnemy();
            
            // 执行第一次攻击
            if (m_CurrentTarget != null && !m_CurrentTarget.HealthComponent.IsDead)
            {
                ExecuteAttack(entity, m_CurrentTarget);
                Logger.Log("AttackState", $"进入攻击状态 ===>>> {entity.name} 攻击目标: {m_CurrentTarget.name}");
            }
            else
            {
                // 如果没有目标，切换到空闲状态
                Logger.Log("AttackState", $"{entity.name} 没有找到目标，切换到空闲状态");
                if (entity is Zombie)
                {
                    entity.FSMComponent.ChangeStatus(FSMType.Move);
                }
                else
                {
                    entity.FSMComponent.ChangeStatus(FSMType.Idle);
                }
            }
        }
    }

    public void Exit(Entity entity, params object[] args)
    {
        // 停止攻击动画
        if (entity.Animator != null)
        {
            entity.Animator.SetBool("attack", false);
        }
        
        m_CurrentTarget = null;
        m_Rigidbody = null;
    }

    public void Process(Entity entity, params object[] args)
    {
        if (entity == null) return;

        // 检查生命值
        if (entity.HealthComponent.CurHealth <= 0)
        {
            entity.FSMComponent.ChangeStatus(FSMType.Dead);
            return;
        }

        // 检查是否需要查找攻击目标
        bool requiresTarget = entity.AttackComponent?.AttackData?.RequiresTarget ?? true;
        
        if (!requiresTarget)
        {
            // 不需要目标的技能（如向日葵生产阳光、火爆辣椒等）
            // 检查是否是资源生产类型（需要处理冷却时间）
            bool isProduceType = entity.AttackComponent?.AttackData?.Type == AttackType.Produce;
            // 检查是否是火爆辣椒类型（一次性使用）
            bool isJalapenoType = entity.AttackComponent?.AttackData is JalapenoSkillData;
            
            if (isProduceType)
            {
                // 资源生产类型：不需要目标，只需要等待冷却时间
                // 更新攻击冷却时间
                if (m_AttackCooldown > 0)
                {
                    m_AttackCooldown -= Time.deltaTime;
                }
                
                // 确保停止移动
                if (m_Rigidbody != null)
                {
                    m_Rigidbody.velocity = Vector2.zero;
                }
                
                // 攻击冷却时间到了，执行攻击（资源生产策略内部会处理重复生成）
                // 注意：ProduceStrategy 使用协程自动生成，这里只需要在第一次进入时执行
                // 后续的生成由 ProduceStrategy 的协程控制
                return;
            }
            
            if (isJalapenoType)
            {
                // 火爆辣椒类型：一次性使用，攻击后会自动销毁
                // 确保停止移动
                if (m_Rigidbody != null)
                {
                    m_Rigidbody.velocity = Vector2.zero;
                }
                
                // 攻击已经在Enter时执行，这里不需要重复执行
                // 等待植物被销毁或切换到其他状态
                return;
            }
            
            // 检查是否是土豆地雷类型（一次性使用）
            bool isPotatoMineType = entity.AttackComponent?.AttackData is PotatoMineSkillData;
            if (isPotatoMineType)
            {
                // 土豆地雷类型：一次性使用，攻击后会自动销毁
                // 确保停止移动
                if (m_Rigidbody != null)
                {
                    m_Rigidbody.velocity = Vector2.zero;
                }
                
                // 攻击已经在Enter时执行，这里不需要重复执行
                // 等待植物被销毁或切换到其他状态
                return;
            }
            
            // 其他不需要目标的技能类型
            // 确保停止移动
            if (m_Rigidbody != null)
            {
                m_Rigidbody.velocity = Vector2.zero;
            }
            return;
        }

        // 其他攻击类型：需要目标
        // 更新攻击冷却时间
        if (m_AttackCooldown > 0)
        {
            m_AttackCooldown -= Time.deltaTime;
        }

        // 检查目标是否仍然有效
        if (m_CurrentTarget == null || m_CurrentTarget.HealthComponent.IsDead)
        {
            // 重新查找目标
            m_CurrentTarget = entity.AttackComponent?.FindEnemy();
        }

        // 如果仍然没有目标，切换到其他状态
        if (m_CurrentTarget == null || m_CurrentTarget.HealthComponent.IsDead)
        {
            Logger.Log("AttackState", $"{entity.name} 目标已消失，切换到其他状态");
            if (entity is Zombie)
            {
                entity.FSMComponent.ChangeStatus(FSMType.Move);
            }
            else
            {
                entity.FSMComponent.ChangeStatus(FSMType.Idle);
            }
            return;
        }

        // 检查目标是否在攻击范围内
        float distance = Vector3.Distance(entity.transform.position, m_CurrentTarget.transform.position);
        float attackRange = entity.AttackComponent?.AttackData?.Range ?? 1.0f;
        
        if (distance > attackRange)
        {
            // 目标超出攻击范围，切换到移动状态（僵尸）或空闲状态（植物）
            Logger.Log("AttackState", $"{entity.name} 目标超出攻击范围，distance:{distance},attackRange:{attackRange},切换到其他状态");
            if (entity is Zombie)
            {
                entity.FSMComponent.ChangeStatus(FSMType.Move);
            }
            else
            {
                entity.FSMComponent.ChangeStatus(FSMType.Idle);
            }
            return;
        }

        // 确保停止移动
        if (m_Rigidbody != null)
        {
            m_Rigidbody.velocity = Vector2.zero;
        }

        // 攻击冷却时间到了，执行攻击
        if (m_AttackCooldown <= 0)
        {
            ExecuteAttack(entity, m_CurrentTarget);
            
            // 重置攻击冷却时间
            float attackInterval = entity.AttackComponent?.AttackData?.Interval ?? 1.0f;
            m_AttackCooldown = attackInterval;
        }
    }

    /// <summary>
    /// 执行攻击
    /// </summary>
    private void ExecuteAttack(Entity entity, Entity target)
    {
        if (entity.AttackComponent == null || entity.AttackComponent.AttackStrategy == null)
        {
            Logger.LogWarning("AttackState", $"{entity.name} 没有攻击组件或攻击策略");
            return;
        }

        // 检查是否需要查找攻击目标
        bool requiresTarget = entity.AttackComponent?.AttackData?.RequiresTarget ?? true;
        
        if (!requiresTarget)
        {
            // 不需要目标的技能，直接执行
            entity.AttackComponent.AttackStrategy.Execute(null);
            Logger.Log("AttackState", $"{entity.name} 执行技能（无需目标）");
        }
        else
        {
            // 其他攻击类型：需要目标
            if (target == null)
            {
                Logger.LogWarning("AttackState", $"{entity.name} 攻击目标无效");
                return;
            }
            
            // 执行攻击策略
            entity.AttackComponent.AttackStrategy.Execute(target);
            
            Logger.Log("AttackState", $"{entity.name} 攻击 {target.name}");
        }
    }
}
